package com.jonas.jgraph.inter;

import android.animation.TimeInterpolator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.Shader;
import android.support.annotation.NonNull;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.animation.BounceInterpolator;

import com.jonas.jgraph.BuildConfig;
import com.jonas.jgraph.graph.StateConstant;
import com.jonas.jgraph.graph.StyleAnnotation;
import com.jonas.jgraph.models.Jchart;
import com.jonas.jgraph.utils.MathHelper;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @author yun.
 * @date 2016/7/11
 * @des [图表控件的基类  finish 图表区域，横纵轴数据]
 * @since [https://github.com/ZuYun]
 * <p><a href="https://github.com/ZuYun">github</a>
 * GestureDetector这个类对外提供了两个接口和一个外部类
 * 接口：OnGestureListener，OnDoubleTapListener
 * 内部类:SimpleOnGestureListener
 */
public abstract class BaseGraph extends BaseGraphView {
    private static final String TAG = BaseGraph.class.getSimpleName();

    protected boolean showDottedLine = true;  // 显示虚线

    public boolean isShowDottedLine() {
        return showDottedLine;
    }

    public void setShowDottedLine(boolean showDottedLine) {
        this.showDottedLine = showDottedLine;
    }

    /**
     * 设置可滚动的时候 建议同时可见个数{@link #setVisibleNums(int)}
     */
    public void setScrollAble(boolean scrollAble) {
        mScrollAble = scrollAble;
        mSliding = 0;//可滚动转不可滚动时移动距离置为0
        if (mWidth > 0) {
            refreshChartSetData();
        }
    }

    ///**
    // * 在不可滚动时 最多显示可见个数
    // * <p color="red">mVisibleNums>=mExecels.size 否则部分不可见
    // */
    ////protected boolean mForceFixNums;

    /**
     * 选中的 柱状图
     */
    protected int mSelected = -1;  //检查点击到哪个柱形图得到结果 （重 0 开始为第一个）

    /**
     * 选中后的背景画笔(画背景)
     */
    protected Paint mSelectedTextBgPaint;
    /**
     * 选中后的文本画笔
     */
    protected Paint mSelectedTextPaint;

    public String getmYaxismax() {
        return mYaxismax;
    }

    public void setmYaxismax(String mYaxismax) {
        this.mYaxismax = mYaxismax;
    }

    /**
     * 允许范围内的误差
     */
    private float mAllowError = 8;  //点击误差大小

    /**
     * 图表区域 最右边 横坐标
     */
    protected float mChartRithtest_x;  //得到 最后一个数据组形体的顶部中点坐标横坐标
    public float getMChartRithtest_x(){
        return mChartRithtest_x;
    }
    protected float mChartLeftest_x;  // 最左边的
    /**
     * 图表区域的宽度
     */
    protected float mCharAreaWidth;  // 可以画图表区域的宽度
    private float mHeightRatio;     // 可以画图表区域的宽度

    /**
     * 顶部选中文字 三角尖的高度
     */
    protected float mBgTriangleHeight;
    /**
     * 柱形图宽度
     */
    protected float mBarWidth = -1;

    public float getMBarWidth(){
        return mBarWidth;
    }

    /**
     * 选中文字背景 三角尖处 距离图表的距离
     */
    protected float mSelectedTextMarging = 4;

    protected ArrayList<PointF> mAllPoints = new ArrayList<>();  // 存储所有的数据点

    /**
     * 间隔宽度
     */
    protected float mInterval = 0;  // 柱形图间的间隔宽度

    public float getInterval() {
        return mInterval;
    }

    public void setInterval(float interval) {
        mInterval = interval;
    }

    /**
     * 图表 在横轴 上方多少距离
     */
    private int mAbove;  // 柱形图的底部距离实线的距离

    /**
     * 最高的点
     */
    protected Jchart mHeightestChart;  //拿到最大值的Jchart
    protected Jchart mMinestChart;  //数据中的最小值的Jchart
    /**
     * 这两个没使用到
     */
    protected Jchart mLastJchart;  //数据中最后一个数据
    protected Jchart mFirstJchart;  //数据中的第一个数据

    protected int mState = 0;

    private OnGraphItemListener mListener;
    /**
     * 图表 数据集合
     */
    protected List<Jchart> mJcharts = new ArrayList<>();

    public List<Jchart> getMJcharts(){
        return mJcharts;
    }

    /**
     * 存储原始数据 /上一次的数据
     */
    protected ArrayList<PointF> mAllLastPoints = new ArrayList<>();
    protected ValueAnimator mValueAnimator = new ValueAnimator();

    /**
     * 越来越快	AccelerateInterpolator()
     * 越来越慢	DecelerateInterpolator()
     * 先快后慢	AccelerateDecelerateInterpolator()
     * 先后退一小步然后向前加速	AnticipateInterpolator()
     * 快速到达终点超出一小步然后回到终点	OvershootInterpolator()
     * 到达终点超出一小步然后回到终点	AnticipateOvershootInterpolator()
     * 弹球效果，弹几下回到终点	BounceInterpolator()
     * 均匀速度	LinearInterpolator()
     */
    private TimeInterpolator mInterpolator = new BounceInterpolator();
    private static final long ANIDURATION = 1100;  // 值动画执行时间

    public BaseGraph(Context context) {
        this(context, null);
    }

    public BaseGraph(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public BaseGraph(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }

    /**
     * 初始化
     */
    protected void init(Context context) {
        mContext = context;

        /**
         * 选中的背景画笔
         */
        mSelectedTextBgPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //显示在顶部 选中的文字背景颜色
        mSelectedTextBgPaint.setColor(Color.GRAY);
        mBgTriangleHeight = MathHelper.dip2px(mContext, 6);  //三脚尖高度
        /**
         * 选中后的文本画笔
         */
        mSelectedTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //顶部选中文字 颜色
        mSelectedTextPaint.setTextAlign(Paint.Align.CENTER);
        mSelectedTextPaint.setColor(Color.WHITE);
        mSelectedTextPaint.setTextSize(MathHelper.dip2px(mContext, 12));

        mBarWidth = MathHelper.dip2px(mContext, 10);//默认的柱子宽度
        mInterval = MathHelper.dip2px(mContext, 4);//默认的间隔大小
    }

    /**
     * onSizeChanged 当view的大小发生变化时触发
     * setBackgroundResource(R.drawable.tabswitcher_long);  可触发
     */
    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (mGraphStyle == StateConstant.BAR || mGraphStyle == StateConstant.LINE) {
            refreshChartArea();  //刷新画表区域
        }
    }

    /**
     * 刷新 画图表的区域
     */
    protected void refreshChartArea() {
        initChartArea();
        refreshChartSetData();
    }

    /**
     * 柱子宽 间隔宽度
     *
     */
    protected void refreshChartSetData() {
        if (mGraphStyle == StateConstant.BAR) {  //柱状图
            //柱状图默认 间隔固定 8>= 12
            mInterval = mInterval >= MathHelper.dip2px(mContext, 6) ? MathHelper.dip2px(mContext, 6) : mInterval;  //取小的
            //            mFixBarWidth = false;
        } else {
            //折线图 默认柱子宽度固定 小点
            mBarWidth = 3;  // 占居宽度
        }

        if (mScrollAble) {
            mVisibleNums = mVisibleNums <= 0 ? 5 : mVisibleNums;//可滚动的状态下 默认可见个数为5
        } else {
            //不可滚动的状态下 可见的数量必须 大于等于 数据数量
            mVisibleNums = mVisibleNums >= mJcharts.size() ? mVisibleNums : mJcharts.size();
        }

        //画 图表区域的宽度
        mCharAreaWidth = mChartArea.right - mChartArea.left;
        //不可滚动 则必须全部显示在界面上  无视mVisibleNums
        if (mGraphStyle == StateConstant.BAR) {
            //间隔 minterval默认 计算柱子宽度
            mBarWidth = (mCharAreaWidth - mInterval * (mVisibleNums - 1)) / mVisibleNums; //开始时无mInterval，结束也没有 所以少一个
        } else {
            mInterval = (mCharAreaWidth - mBarWidth * mVisibleNums) / (mVisibleNums - 1);
        }
        refreshExcels();
    }

    /**
     * 主要 刷新高度
     */
    protected void refreshExcels() {
        if (mJcharts == null || mJcharts.size() <= 0) {
            if (BuildConfig.DEBUG) {
                Log.e(TAG, "数据为空 ");
            }
            return;
        }
        findTheBestChart();  //发现图表最大数值便于缩放
        mHeightRatio = (mChartArea.bottom - mChartArea.top) / (mYaxis_Max - mYaxis_min);  //比例
        for (int i = 0; i < mJcharts.size(); i++) {
            Jchart jchart = mJcharts.get(i);
            jchart.setLowStart(mYaxis_min);  //设置y轴的最小值（来自数组中的最小值）
            jchart.setHeightRatio(mHeightRatio);  //设置比例
            jchart.setWidth(mBarWidth);  //设置柱状体的宽度，线型图默认为3
            PointF start = jchart.getStart();
            jchart.setIndex(i);  //设置柱形图编号
            start.x = mChartArea.left + mBarWidth * i + mInterval * i;  //x坐标
            start.y = mChartArea.bottom - mAbove;   //y坐标
            refreshOthersWithEveryChart(i, jchart);
        }
        mChartRithtest_x = mJcharts.get(mJcharts.size() - 1).getMidPointF().x;  //得到 最后一个数据组形体的顶部中点坐标
        mChartLeftest_x = mJcharts.get(0).getMidPointF().x; //最左边的
    }

    /**
     * 根据每一个chart刷新其他需要的数据
     */
    protected void refreshOthersWithEveryChart(int i, Jchart jchart) {

    }

    protected void findTheBestChart() {  //发现最大的数据值便于图表缩放
        /**
         * 这两个暂时没有使用到
         */
        if (mJcharts == null || mJcharts.size() <= 0) {
            return;
        }
        // 得到首个 和 最后一个数据
        if (mJcharts != null && mJcharts.size() > 0) {
            mFirstJchart = mJcharts.get(0);
            mLastJchart = mJcharts.get(mJcharts.size() - 1);
        }
        // 得到最大的数据值（upper）
        mHeightestChart = Collections.max(mJcharts, new Comparator<Jchart>() {
            @Override
            public int compare(Jchart lhs, Jchart rhs) {
                return (int) (lhs.getTopest() - rhs.getTopest());
            }
        });
        //得到最小的数据值（upper）
        mMinestChart = Collections.min(mJcharts, new Comparator<Jchart>() {
            @Override
            public int compare(Jchart lhs, Jchart rhs) {
                return (int) (lhs.getTopest() - rhs.getTopest());
            }
        });

        if (BuildConfig.DEBUG) {
            Log.d(TAG, "最大值：" + mHeightestChart.getTopest());
        }
        //最大值 整10向上取整
        if (mYaxis_msg == null || mYaxis_msg.size() == 0) {
            // ToDo 这里对最大值进行处理
            mYaxis_Max = MathHelper.getCeil10(mHeightestChart.getTopest());
            //默认 y轴显示两段三个刻度
            refreshYaxisValues();
        } else {
            if (mYaxis_Max < mHeightestChart.getTopest() || mYaxis_min > mMinestChart.getTopest()) {
                //纵轴的 最大值 要比数据最大还大
                mYaxis_Max = mYaxis_Max < mHeightestChart.getTopest() ? MathHelper
                        .getCeil10(mHeightestChart.getTopest()) : mYaxis_Max;
                if (mYaxis_min > mMinestChart.getTopest()) {
                    //最小数整10向下取整
                    mYaxis_min = MathHelper.getCast10(mMinestChart.getTopest());
                }
                //纵轴的 最小值 要比数据最小还小
                showYnum = mYaxis_msg.size();
                refreshYaxisValues();
            }
        }
    }

    /**
     * 在此绘图
     */
    @Override
    protected void onDraw(Canvas canvas) {
        if (null != mJcharts && mJcharts.size() > 0) {
            if (showDottedLine) { // 是否画虚线
                drawYabscissaMsg(canvas, mJcharts, mChartRithtest_x, mBarWidth);  //画纵轴文字和虚线
            }
            if (mGraphStyle == StateConstant.BAR) {
                drawSugExcel_BAR(canvas);   //画柱形图
            } else if (mGraphStyle == StateConstant.LINE) {
                drawSugExcel_LINE(canvas);   //画折线图
            } else {
                drawSugExcel_BAR(canvas);   //画柱形图
                drawSugExcel_LINE(canvas);   //画折线图
            }
            //选中模式启用的时候
            if (mSelectedMode == StateConstant.SELECETD_MSG_SHOW_TOP && !mValueAnimator.isRunning()) {
                if (mSelected > -1) {
                    drawSelectedText(canvas, mJcharts.get(mSelected));  // 画背景
                } else {
                    drawSelectedText(canvas, mJcharts.get(mHeightestChart.getIndex()));  //没选中 标识出最高的数值的背景
                }
            }
            for (Jchart excel : mJcharts) {
                drawAbscissaMsg(canvas, excel);  // 画横坐标信息
            }
        }
        //画横轴
        float coordinate_x = mChartRithtest_x + mBarWidth / 2;
        drawCoordinateAxes(canvas, mCoordinatePaint, coordinate_x);

    }

    /**
     * View 的手势监听
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mSelectedMode == -1 && !mScrollAble) {  //如果不允许点击且不滚动 就直接不处理否者
            return false;
        }
        return super.onTouchEvent(event);
    }

    @Override
    public void onClick() {
        mSelected = clickWhere(tup);  // 判断点击在哪个柱形图上
        if (mListener != null) {  // mListener 需要外层传入
            mListener.onItemClick(mSelected);
        }
    }

    @Override
    public boolean onScrollHandler(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
        return judgeSliding(-distanceX);  //更新滑动值
    }

    @Override
    public void onLongClick() {
        mSelected = clickWhere(longtup);
        if (mListener != null) {
            mListener.onItemLongClick(mSelected);  // 外部处理
        }
    }

    @Override
    public void computeScroll() {
        super.computeScroll();
        if (vSliding != -1) {  // 判断滑动完成
            judgeSliding(vSliding);  // 滑动距离处理
        }
    }

    /**
     * 滑动屏幕处理方法
     */
    protected boolean judgeSliding(float tempSlided) {  // 右划传入为正
        if (!mScrollAble) {
            return false;
        }
        mSliding += tempSlided;  //mSliding 累计滑动量
        if (mJcharts != null && mJcharts.size() > 0) {
            if (mSliding >= 0 || mSliding <= -(mChartRithtest_x - mCharAreaWidth)) {
                //跨越两边界了
                mSliding = mSliding >= 0 ? 0
                        : mSliding <= -(mChartRithtest_x - mCharAreaWidth) ? -(mChartRithtest_x - mCharAreaWidth)
                                : mSliding;
                invalidate();
                return false;
            } else {
                //正常滑动距离刷新界面
                invalidate();
                return true;
            }
        } else {
            mSliding = mSliding >= 0 ? 0 : mSliding;
            invalidate();
            return false;
        }
    }

    /**
     * 判断 点中哪个柱状图
     */
    protected int clickWhere(PointF tup) {
        if (mChartArea == null) {
            return -1;
        }
        float clickEffective_x = tup.x - mChartArea.left - mSliding; // 有效的x 减去了左边的边距
        if (clickEffective_x > 0) {   // 点击有效  在柱状图范围内
            clickEffective_x = tup.x - mChartArea.left - mBarWidth - mInterval / 2 - mSliding;  //减去了左边第一个宽度
            if (clickEffective_x > 0) {   // 表示点击在第二个以后
                int maybeSelected = (int) (clickEffective_x / (mBarWidth + mInterval)) + 1;  //会比现实少一个  后面处理，用于 0计数起
                if (maybeSelected >= mJcharts.size()) {  //超出范围
                    return -1;
                }
                //判断y
                Jchart jchart = mJcharts.get(maybeSelected); // 得到存储对象
                if (tup.y > jchart.getMidPointF().y - mAllowError) {
                    return maybeSelected;
                } else {
                    return -1;
                }
            } else {  // 点击在第一个  返回下标为 0
                //判断 y
                Jchart jchart = mJcharts.get(0);
                if (tup.y > jchart.getMidPointF().y - mAllowError) {
                    return 0;
                } else {
                    return -1;
                }
            }
        } else {
            return -1;
        }
    }

    protected void drawSelectedText(Canvas canvas, Jchart excel) {

    }

    ///**
    // * 画选中的 顶部文字和背景
    // */
    //protected void drawSelectedText(Canvas canvas, Jchart excel) {
    //    PointF midPointF = excel.getMidPointF();  //获取选中柱形体中点的坐标
    //    //        String msg = excel.getUpper() + excel.getUnit();
    //    String msg = excel.getShowMsg();  // 选中后要显示的信息
    //    Rect mBounds = new Rect();  // 矩形
    //    mSelectedTextPaint.getTextBounds(msg, 0, msg.length(), mBounds);  // 为画笔设置文字
    //    Path textBg = new Path();
    //    //        mSelectedTextPaint.getTextSize() > mBounds.height()
    //    float bgWidth = MathHelper.dip2px(mContext, 8);  // 默认三角形背景宽度  16
    //
    //    textBg.moveTo(midPointF.x, midPointF.y - mSelectedTextMarging);
    //    textBg.lineTo(midPointF.x - bgWidth / 2, midPointF.y - mSelectedTextMarging - mBgTriangleHeight - 1.5f);
    //    textBg.lineTo(midPointF.x + bgWidth / 2, midPointF.y - mSelectedTextMarging - mBgTriangleHeight - 1.5f);
    //    textBg.close();  //形成封闭的图形
    //    //ToDo 画text bg 的三角形
    //    canvas.drawPath(textBg, mSelectedTextBgPaint);
    //    // 选中时的背景矩形
    //    RectF rectF = new RectF(midPointF.x - mBounds.width() / 2f - bgWidth,  //减去文字宽度一半，减去默认宽度
    //            //减去 三角形尖距离y的值 减去 三角形高度  减去 字体高度  减去 两个三角形高度
    //            midPointF.y - mSelectedTextMarging - mBgTriangleHeight - mBounds.height() - mBgTriangleHeight * 2f,
    //            midPointF.x + mBounds.width() / 2f + bgWidth, midPointF.y - mSelectedTextMarging - mBgTriangleHeight);
    //    float dffw = 0;  // 超出多少
    //    if (!mScrollAble) {
    //        //防止 画出到屏幕外
    //        dffw = rectF.right - mWidth - getPaddingRight() - getPaddingLeft();
    //    }
    //    float msgX = midPointF.x;
    //    float magin = 1;
    //    if (dffw > 0) {  // 超出了屏幕
    //        rectF.right = rectF.right - dffw - magin;
    //        rectF.left = rectF.left - dffw - magin;
    //        msgX = midPointF.x - dffw - magin;
    //    } else if (rectF.left < 0) {  // 左边超出了
    //        rectF.right = rectF.right - rectF.left + magin;
    //        msgX = midPointF.x - rectF.left + magin;
    //        rectF.left = magin;
    //    }
    //    // ToDo 画选中的椭圆效果
    //    canvas.drawRoundRect(rectF, 3, 3, mSelectedTextBgPaint);
    //    // ToDo 画选中了的文本
    //    canvas.drawText(msg, msgX, midPointF.y - mSelectedTextMarging - mBgTriangleHeight * 2, mSelectedTextPaint);
    //}

    /**
     * 画柱状图
     */
    protected void drawSugExcel_BAR(Canvas canvas) {
    }

    /**
     * 画 折线
     */
    protected void drawSugExcel_LINE(Canvas canvas) {
    }

    /**
     * 为画笔 设置 渲染器
     */
    protected void paintSetShader(Paint paint, int[] shaders, float x0, float y0, float x1, float y1) {
        if (shaders != null && shaders.length > 1) {  // 渐变色不为空
            float[] position = new float[shaders.length];  // 颜色数组
            float v = 1f / shaders.length;   //每个颜色的比例
            float temp = 0;
            if (shaders.length > 2) {  // 颜色大于2
                for (int i = 0; i < shaders.length; i++) {
                    position[i] = temp;  // 0  到 1-v
                    temp += v;
                }
            } else {
                position[0] = 0;
                position[1] = 1;
            }
            paint.setShader(new LinearGradient(x0, y0, x1, y1, shaders, position, Shader.TileMode.CLAMP));  // 设置着色器
        } else if (paint.getShader() != null) {  // 否则不着色
            paint.setShader(null);
        }
    }

    /**
     * 动画展示效果
     */
    public void aniShowChar(float start, float end) {
        aniShowChar(start, end, mInterpolator, ANIDURATION);
    }

    public void aniShowChar(float start, float end, TimeInterpolator interpolator) {
        aniShowChar(start, end, interpolator, 1000);
    }

    public void aniShowChar(float start, float end, TimeInterpolator interpolator, long duration) {
        aniShowChar(start, end, interpolator, duration, false);
    }

    /**
     * @param start 值动画开始的数值
     * @param end 值动画结束的数值
     * @param interpolator 直译过来的话是补间器的意思，它的主要作用是可以控制动画的变化速率，
     * @param duration 动画执行的时间
     * @param intvalue true 值动画为 int 型  false 值动画为flaot型的
     */
    public void aniShowChar(float start, float end, TimeInterpolator interpolator, long duration, boolean intvalue) {
        mValueAnimator.cancel();  // 值动画清理
        if (intvalue) {
            mValueAnimator = ValueAnimator.ofInt(((int) start), ((int) end));
        } else {
            mValueAnimator = ValueAnimator.ofFloat(start, end);
        }
        mValueAnimator.setDuration(duration);  // 表示动画执行时间 1000 为1s
        mValueAnimator.setInterpolator(interpolator);  // 设置动画展示效果
        mValueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                onAnimationUpdating(animation);  // 子类重写此方法
            }
        });
        mValueAnimator.start();
    }

    protected void onAnimationUpdating(ValueAnimator animation) {  // 动画值更新
    }

    /**
     * 传入 数据
     */
    public void feedData(@NonNull Jchart... jcharts) {
        feedData(new ArrayList<Jchart>(Arrays.asList(jcharts)));
    }

    /**
     * 传入 数据
     */
    public void feedData(@NonNull List<Jchart> jchartList) {
        mSelected = -1;  // 点击记录清 空
        mJcharts.clear();  // 当前数据清空
        if (jchartList != null && jchartList.size() > 0) {
            mJcharts.addAll(jchartList);  // 添加到 mJcharts
            mAllLastPoints = new ArrayList<>(jchartList.size());
            for (int i = 0; i < mJcharts.size(); i++) {
                Jchart jchart = mJcharts.get(i);
                jchart.setIndex(i);  // 设置数据为第几个
                mAllLastPoints.add(new PointF(jchart.getMidX(), -1));
            }

            if (mWidth > 0) {
                //已经显示在界面上了 重新设置数据
                refreshChartSetData();
            }

        } else {
            if (BuildConfig.DEBUG) {//in lib DEBUG always false
                Log.e(TAG, "数据异常 ");
            }
        }
    }



    public void setOnGraphItemListener(OnGraphItemListener listener) {
        mListener = listener;
    }

    public void setInterpolator(TimeInterpolator interpolator) {
        mInterpolator = interpolator;
    }

    /**
     * 设置y轴 刻度 信息
     *
     * @param showMsg y轴显示 内容
     */
    public void setYaxisValues(@NonNull String... showMsg) {
        setYaxisValues(Arrays.asList(showMsg));
    }

    /**
     * 设置y轴 刻度 信息  0开始
     *
     * @param max y轴显示的最大值
     */
    public void setYaxisMinMaxValues(int min, int max) {
        super.setYaxisMinMaxValues(min, max);
        refreshExcels();
    }

    /**
     * onAttachedToWindow 是在第一次onDraw前调用的。也就是我们写的View在没有绘制出来时调用的，但只会调用一次。
     * onDetachedFromWindow 我们销毁View的时候。我们写的这个View不再显示。
     */
    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if (mValueAnimator.isRunning()) {
            mValueAnimator.cancel();  // 取消值动画
        }
        mChartArea = null;
        mAllLastPoints.clear();
        mAllPoints.clear();
        mJcharts.clear();
    }

    /**
     * 坐标 信息 文字大小
     */
    public void setAbscissaMsgSize(int abscissaMsgSize) {
        horizontalAxisTextSize = abscissaMsgSize;
    }

    /**
     * 设置 图表类型  柱状 折线  折线+柱状
     */
    public void setGraphStyle(@StyleAnnotation.GraphStyle int graphStyle) {
        mGraphStyle = graphStyle;
        if (mWidth > 0) {
            refreshChartSetData();
        }
    }

    /**
     * 图表 距离 横轴的距离
     */
    public void setAbove(int above) {
        mAbove = above;
        refreshExcels();
    }



    public int getSelected() {
        return mSelected;
    }

    /**
     * 设置 选中的
     */
    public void setSelected(int selected) {
        mSelected = selected;
    }

    public void setSelectedTextSize(float textSize) {
        mSelectedTextPaint.setTextSize(textSize);
    }

    /**
     * 设置 可见的柱子个数 点个数
     * 可滚动的情况下 默认可见5个
     */
    public void setVisibleNums(int visibleNums) {
        mVisibleNums = visibleNums;
        if (mWidth > 0) {
            refreshChartSetData();
        }
    }

    public void aniChangeData(List<Jchart> jchartList) {
    }

    public Paint getPaintAbscisDash() {  //虚线的画笔
        return mAbscisDashPaint;
    }

    public Paint getSelectedTextBg() {  //选中文字背景的画笔
        return mSelectedTextBgPaint;
    }

    public Paint getSelectedTextPaint() {  //选中文字的画笔
        return mSelectedTextPaint;
    }

}
